| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391 |
1×
1×
1×
4×
4×
4×
12×
12×
4×
1×
74×
13×
13×
74×
3×
74×
74×
74×
74×
4×
29×
29×
24×
24×
24×
29×
41×
1×
24×
1×
1×
23×
23×
1×
19×
1×
19×
19×
19×
19×
19×
19×
19×
19×
2×
2×
1×
1×
1×
1×
18×
18×
18×
18×
2×
2×
2×
2×
2×
2×
2×
2×
18×
18×
18×
18×
50×
16×
16×
16×
16×
16×
16×
16×
1×
16×
2×
2×
14×
14×
3×
3×
2×
2×
2×
12×
1×
1×
1×
1×
1×
11×
18×
18×
18×
18×
7×
18×
16×
18×
18×
18×
14×
14×
18×
18×
1×
18×
7×
11×
11×
11×
11×
11×
18×
2×
2×
2×
2×
2×
2×
2×
18×
1×
1×
1×
1×
1×
1×
1×
1×
| /**
* ER (Enterprise RIA)
* Copyright 2013 Baidu Inc. All rights reserved.
*
* @ignore
* @file AJAX相关方法
* @author otakustay
*/
define(function (require) {
var TIMESTAMP_PARAM_KEY = '_';
function serializeArray(prefix, array) {
var encodedKey = prefix ? encodeURIComponent(prefix) : '';
var encoded = [];
for (var i = 0; i < array.length; i++) {
var item = array[i];
encoded[i] = this.serializeData('', item);
}
return encodedKey ? encodedKey + '=' + encoded.join(',') : encoded.join(',');
}
function serializeData(prefix, data) {
if (arguments.length === 1) {
data = prefix;
prefix = '';
}
if (data == null) {
data = '';
}
var getKey = this.serializeData.getKey;
var encodedKey = prefix ? encodeURIComponent(prefix) : '';
var type = Object.prototype.toString.call(data);
switch (type) {
case '[object Array]':
return this.serializeArray(prefix, data);
case '[object Object]':
var result = [];
for (var name in data) {
var propertyKey = getKey(name, prefix);
var propertyValue = this.serializeData(propertyKey, data[name]);
result.push(propertyValue);
}
return result.join('&');
default:
return encodedKey ? encodedKey + '=' + encodeURIComponent(data) : encodeURIComponent(data);
}
}
serializeData.getKey = function (propertyName, parentKey) {
return parentKey ? parentKey + '.' + propertyName : propertyName;
};
/**
* @class Ajax
*
* Ajax类
*
* 通过`require('er/ajax').Ajax`访问该类构造函数，其中`require('er/ajax')`是该类的全局实例
*
* @extends mini-event.EventTarget
* @constructor
*/
var exports = {};
exports.constructor = function () {
/**
* AJAX钩子
*
* @type {meta.AjaxHook}
*/
this.hooks = {
serializeData: serializeData,
serializeArray: serializeArray
};
/**
* AJAX配置
*
* @type {meta.AjaxOption}
*/
this.config = {
cache: false,
timeout: 0,
charset: ''
};
};
/**
* 发起`XMLHttpRequest`请求
*
* @param {meta.AjaxOption} options 相关配置
* @return {meta.FakeXHR}
*/
exports.request = function (options) {
if (typeof this.hooks.beforeExecute === 'function') {
this.hooks.beforeExecute(options);
}
var assert = require('./assert');
assert.hasProperty(options, 'url', 'url property is required');
var defaults = {
method: 'POST',
data: {},
cache: this.config.cache,
timeout: this.config.timeout,
charset: this.config.charset
};
var util = require('./util');
options = util.mix(defaults, options);
var Deferred = require('./Deferred');
var requesting = new Deferred();
if (typeof this.hooks.beforeCreate === 'function') {
var canceled = this.hooks.beforeCreate(options, requesting);
if (canceled === true) {
var fakeXHR = requesting.promise;
fakeXHR.abort = function () {};
fakeXHR.setRequestHeader = function () {};
return fakeXHR;
}
}
var xhr = window.XMLHttpRequest ? new XMLHttpRequest() : new window.ActiveXObject('Microsoft.XMLHTTP');
util.mix(xhr, options.xhrFields);
var fakeXHR = requesting.promise;
var xhrWrapper = {
abort: function abort() {
// 有些浏览器`abort()`就会把`readyState`变成4，
// 这就会导致进入处理函数变成**resolved**状态，
// 因此事先去掉处理函数，然后直接进入**rejected**状态
xhr.onreadystatechange = null;
try {
xhr.abort();
} catch (ex) {}
Iif (!fakeXHR.status) {
fakeXHR.status = 0;
}
fakeXHR.readyState = xhr.readyState;
fakeXHR.responseText = '';
fakeXHR.responseXML = '';
requesting.reject(fakeXHR);
},
setRequestHeader: function setRequestHeader(name, value) {
xhr.setRequestHeader(name, value);
},
getAllResponseHeaders: function getAllResponseHeaders() {
return xhr.getAllResponseHeaders();
},
getResponseHeader: function getResponseHeader(name) {
return xhr.getResponseHeader(name);
},
getRequestOption: function getRequestOption(name) {
return options[name];
}
};
util.mix(fakeXHR, xhrWrapper);
var eventObject = { xhr: fakeXHR, options: options };
fakeXHR.then(
/**
* @event done
*
* 任意一个请求成功时触发
*
* @param {meta.AjaxOption} options 请求的配置信息
* @param {meta.FakeXHR} xhr 请求对象
*/
util.bind(this.fire, this, 'done', eventObject),
/**
* @event fail
*
* 任意一个请求失败时触发
*
* @param {meta.FakeXHR} xhr 请求对象
* @param {meta.AjaxOption} options 请求的配置信息
*/
util.bind(this.fire, this, 'fail', eventObject));
var processRequestStatus = function processRequestStatus() {
if (xhr.readyState === 4) {
var status = fakeXHR.status || xhr.status;
// IE9会把204状态码变成1223
Iif (status === 1223) {
status = 204;
}
fakeXHR.status = fakeXHR.status || status;
fakeXHR.readyState = xhr.readyState;
fakeXHR.responseText = xhr.responseText;
fakeXHR.responseXML = xhr.responseXML;
if (typeof this.hooks.afterReceive === 'function') {
this.hooks.afterReceive(fakeXHR, options);
}
// 如果请求不成功，也就不用再分解数据了，直接丢回去就好
if (status < 200 || status >= 300 && status !== 304) {
requesting.reject(fakeXHR);
return;
}
var data = xhr.responseText;
if (options.dataType === 'json') {
try {
data = util.parseJSON(data);
} catch (ex) {
// 服务器返回的数据不符合JSON格式，认为请求失败
fakeXHR.error = ex;
requesting.reject(fakeXHR);
return;
}
}
if (typeof this.hooks.afterParse === 'function') {
try {
data = this.hooks.afterParse(data, fakeXHR, options);
} catch (ex) {
fakeXHR.error = ex;
requesting.reject(fakeXHR);
return;
}
}
// 数据处理成功后，进行回调
requesting.resolve(data);
}
};
xhr.onreadystatechange = util.bind(processRequestStatus, this);
var method = options.method.toUpperCase();
var data = {};
if (method === 'GET') {
util.mix(data, options.data);
}
if (options.cache === false) {
data[TIMESTAMP_PARAM_KEY] = +new Date();
}
var query = this.hooks.serializeData('', data, 'application/x-www-form-urlencoded');
var url = options.url;
if (query) {
var delimiter = url.indexOf('?') >= 0 ? '&' : '?';
url += delimiter + query;
}
xhr.open(method, url, true);
if (typeof this.hooks.beforeSend === 'function') {
this.hooks.beforeSend(fakeXHR, options);
}
if (method === 'GET') {
xhr.send();
} else {
var contentType = options.contentType || 'application/x-www-form-urlencoded';
var query = this.hooks.serializeData('', options.data, contentType, fakeXHR);
Iif (options.charset) {
contentType += ';charset=' + options.charset;
}
xhr.setRequestHeader('Content-Type', contentType);
xhr.send(query);
}
if (options.timeout > 0) {
var notifyTimeout = function notifyTimeout() {
/**
* @event timeout
*
* 任意一个请求成功时触发，
* 在此事件后会再触发一次{@link Ajax#fail}事件
*
* @param {meta.FakeXHR} xhr 请求对象
* @param {meta.AjaxOption} options 请求的配置信息
*/
this.fire('timeout', { xhr: fakeXHR, options: options });
fakeXHR.status = 408; // HTTP 408: Request Timeout
fakeXHR.abort();
};
var tick = setTimeout(util.bind(notifyTimeout, this), options.timeout);
fakeXHR.ensure(function () {
clearTimeout(tick);
});
}
return fakeXHR;
};
/**
* 发起一个`GET`请求
*
* @param {string} url 请求的地址
* @param {Object} [data] 请求的数据
* @param {boolean} [cache] 决定是否允许缓存
* @return {meta.FakeXHR}
*/
exports.get = function (url, data, cache) {
var options = {
method: 'GET',
url: url,
data: data,
cache: cache || this.config.cache
};
return this.request(options);
};
/**
* 发起一个`GET`请求并获取JSON数据
*
* @param {string} url 请求的地址
* @param {Object} [data] 请求的数据
* @param {boolean} [cache] 决定是否允许缓存
* @return {meta.FakeXHR}
*/
exports.getJSON = function (url, data, cache) {
var options = {
method: 'GET',
url: url,
data: data,
dataType: 'json',
cache: cache || this.config.cache
};
return this.request(options);
};
/**
* 发起一个`POST`请求
*
* @param {string} url 请求的地址
* @param {Object} [data] 请求的数据
* @param {string} [dataType="json"] 指定响应的数据格式
* @return {meta.FakeXHR}
*/
exports.post = function (url, data, dataType) {
var options = {
method: 'POST',
url: url,
data: data,
dataType: dataType || 'json'
};
return this.request(options);
};
/**
* 发送一个日志请求，该请求只负责发出，不负责保证送达，且不支持回调函数
*
* @param {string} url 发送的目标URL
* @param {Object} [data] 额外添加的参数
*/
exports.log = function (url, data) {
var img = new Image();
var pool = window.ER_LOG_POOL || (window.ER_LOG_POOL = {});
var id = +new Date();
pool[id] = img;
img.onload = img.onerror = img.onabort = function () {
// 如果这个img很不幸正好加载了一个存在的资源，又是个gif动画，
// 则在gif动画播放过程中，img会多次触发onload，因此一定要清空
img.onload = img.onerror = img.onabort = null;
pool[id] = null;
// 下面这句非常重要，
// new Image创建的是DOM，
// DOM的事件中形成闭包环引用DOM是典型的内存泄露，
// 因此这里一定要置为null
img = null;
};
var query = this.hooks.serializeData('', data, 'application/x-www-form-urlencoded');
if (query) {
var delimiter = url.indexOf('?') >= 0 ? ':' : '?';
url += delimiter + query;
}
// 一定要在注册了事件之后再设置src，
// 不然如果图片是读缓存的话，会错过事件处理，
// 最后，对于url最好是添加客户端时间来防止缓存，
// 同时服务器也配合一下传递`Cache-Control: no-cache;`
img.src = url;
};
var Ajax = require('eoo').create(require('fc-mini-event/EventTarget'), exports);
var instance = new Ajax();
instance.Ajax = Ajax;
return instance;
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/ajax.js"],"names":[],"mappings":"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","file":"ajax.js","sourcesContent":["/**\n * ER (Enterprise RIA)\n * Copyright 2013 Baidu Inc. All rights reserved.\n *\n * @ignore\n * @file AJAX相关方法\n * @author otakustay\n */\ndefine(\n    function (require) {\n        var TIMESTAMP_PARAM_KEY = '_';\n\n        function serializeArray(prefix, array) {\n            var encodedKey = prefix ? encodeURIComponent(prefix) : '';\n            var encoded = [];\n            for (var i = 0; i < array.length; i++) {\n                var item = array[i];\n                encoded[i] = this.serializeData('', item);\n            }\n            return encodedKey\n                ? encodedKey + '=' + encoded.join(',')\n                : encoded.join(',');\n        }\n\n        function serializeData(prefix, data) {\n            if (arguments.length === 1) {\n                data = prefix;\n                prefix = '';\n            }\n\n            if (data == null) {\n                data = '';\n            }\n            var getKey = this.serializeData.getKey;\n            var encodedKey = prefix ? encodeURIComponent(prefix) : '';\n\n            var type = Object.prototype.toString.call(data);\n            switch (type) {\n                case '[object Array]':\n                    return this.serializeArray(prefix, data);\n                case '[object Object]':\n                    var result = [];\n                    for (var name in data) {\n                        var propertyKey = getKey(name, prefix);\n                        var propertyValue = this.serializeData(propertyKey, data[name]);\n                        result.push(propertyValue);\n                    }\n                    return result.join('&');\n                default:\n                    return encodedKey\n                        ? encodedKey + '=' + encodeURIComponent(data)\n                        : encodeURIComponent(data);\n            }\n        }\n\n        serializeData.getKey = function (propertyName, parentKey) {\n            return parentKey ? parentKey + '.' + propertyName : propertyName;\n        };\n\n        /**\n         * @class Ajax\n         *\n         * Ajax类\n         *\n         * 通过`require('er/ajax').Ajax`访问该类构造函数，其中`require('er/ajax')`是该类的全局实例\n         *\n         * @extends mini-event.EventTarget\n         * @constructor\n         */\n        var exports = {};\n        exports.constructor = function () {\n            /**\n             * AJAX钩子\n             *\n             * @type {meta.AjaxHook}\n             */\n            this.hooks = {\n                serializeData: serializeData,\n                serializeArray: serializeArray\n            };\n\n            /**\n             * AJAX配置\n             *\n             * @type {meta.AjaxOption}\n             */\n            this.config = {\n                cache: false,\n                timeout: 0,\n                charset: ''\n            };\n        };\n\n        /**\n         * 发起`XMLHttpRequest`请求\n         *\n         * @param {meta.AjaxOption} options 相关配置\n         * @return {meta.FakeXHR}\n         */\n        exports.request = function (options) {\n            if (typeof this.hooks.beforeExecute === 'function') {\n                this.hooks.beforeExecute(options);\n            }\n\n            var assert = require('./assert');\n            assert.hasProperty(options, 'url', 'url property is required');\n\n            var defaults = {\n                method: 'POST',\n                data: {},\n                cache: this.config.cache,\n                timeout: this.config.timeout,\n                charset: this.config.charset\n            };\n            var util = require('./util');\n            options = util.mix(defaults, options);\n\n            var Deferred = require('./Deferred');\n            var requesting = new Deferred();\n\n            if (typeof this.hooks.beforeCreate === 'function') {\n                var canceled = this.hooks.beforeCreate(options, requesting);\n                if (canceled === true) {\n                    var fakeXHR = requesting.promise;\n                    fakeXHR.abort = function () {};\n                    fakeXHR.setRequestHeader = function () {};\n                    return fakeXHR;\n                }\n            }\n\n            var xhr = window.XMLHttpRequest\n                ? new XMLHttpRequest()\n                : new window.ActiveXObject('Microsoft.XMLHTTP');\n\n            util.mix(xhr, options.xhrFields);\n\n            var fakeXHR = requesting.promise;\n            var xhrWrapper = {\n                abort: function () {\n                    // 有些浏览器`abort()`就会把`readyState`变成4，\n                    // 这就会导致进入处理函数变成**resolved**状态，\n                    // 因此事先去掉处理函数，然后直接进入**rejected**状态\n                    xhr.onreadystatechange = null;\n                    try {\n                        xhr.abort();\n                    }\n                    catch (ex) {\n                    }\n                    if (!fakeXHR.status) {\n                        fakeXHR.status = 0;\n                    }\n                    fakeXHR.readyState = xhr.readyState;\n                    fakeXHR.responseText = '';\n                    fakeXHR.responseXML = '';\n                    requesting.reject(fakeXHR);\n                },\n                setRequestHeader: function (name, value) {\n                    xhr.setRequestHeader(name, value);\n                },\n                getAllResponseHeaders: function () {\n                    return xhr.getAllResponseHeaders();\n                },\n                getResponseHeader: function (name) {\n                    return xhr.getResponseHeader(name);\n                },\n                getRequestOption: function (name) {\n                    return options[name];\n                }\n            };\n            util.mix(fakeXHR, xhrWrapper);\n\n            var eventObject = { xhr: fakeXHR, options: options };\n            fakeXHR.then(\n                /**\n                 * @event done\n                 *\n                 * 任意一个请求成功时触发\n                 *\n                 * @param {meta.AjaxOption} options 请求的配置信息\n                 * @param {meta.FakeXHR} xhr 请求对象\n                 */\n                util.bind(this.fire, this, 'done', eventObject),\n                /**\n                 * @event fail\n                 *\n                 * 任意一个请求失败时触发\n                 *\n                 * @param {meta.FakeXHR} xhr 请求对象\n                 * @param {meta.AjaxOption} options 请求的配置信息\n                 */\n                util.bind(this.fire, this, 'fail', eventObject)\n            );\n\n            var processRequestStatus = function () {\n                if (xhr.readyState === 4) {\n                    var status = fakeXHR.status || xhr.status;\n                    // IE9会把204状态码变成1223\n                    if (status === 1223) {\n                        status = 204;\n                    }\n\n                    fakeXHR.status = fakeXHR.status || status;\n                    fakeXHR.readyState = xhr.readyState;\n                    fakeXHR.responseText = xhr.responseText;\n                    fakeXHR.responseXML = xhr.responseXML;\n\n                    if (typeof this.hooks.afterReceive === 'function') {\n                        this.hooks.afterReceive(fakeXHR, options);\n                    }\n\n                    // 如果请求不成功，也就不用再分解数据了，直接丢回去就好\n                    if (status < 200 || (status >= 300 && status !== 304)) {\n                        requesting.reject(fakeXHR);\n                        return;\n                    }\n\n                    var data = xhr.responseText;\n                    if (options.dataType === 'json') {\n                        try {\n                            data = util.parseJSON(data);\n                        }\n                        catch (ex) {\n                            // 服务器返回的数据不符合JSON格式，认为请求失败\n                            fakeXHR.error = ex;\n                            requesting.reject(fakeXHR);\n                            return;\n                        }\n                    }\n\n                    if (typeof this.hooks.afterParse === 'function') {\n                        try {\n                            data = this.hooks.afterParse(data, fakeXHR, options);\n                        }\n                        catch (ex) {\n                            fakeXHR.error = ex;\n                            requesting.reject(fakeXHR);\n                            return;\n                        }\n                    }\n\n                    // 数据处理成功后，进行回调\n                    requesting.resolve(data);\n                }\n            };\n\n            xhr.onreadystatechange = util.bind(processRequestStatus, this);\n\n            var method = options.method.toUpperCase();\n            var data = {};\n            if (method === 'GET') {\n                util.mix(data, options.data);\n            }\n            if (options.cache === false) {\n                data[TIMESTAMP_PARAM_KEY] = +new Date();\n            }\n            var query = this.hooks.serializeData('', data, 'application/x-www-form-urlencoded');\n            var url = options.url;\n            if (query) {\n                var delimiter = url.indexOf('?') >= 0 ? '&' : '?';\n                url += delimiter + query;\n            }\n\n            xhr.open(method, url, true);\n\n            if (typeof this.hooks.beforeSend === 'function') {\n                this.hooks.beforeSend(fakeXHR, options);\n            }\n\n            if (method === 'GET') {\n                xhr.send();\n            }\n            else {\n                var contentType = options.contentType || 'application/x-www-form-urlencoded';\n                var query = this.hooks.serializeData('', options.data, contentType, fakeXHR);\n                if (options.charset) {\n                    contentType += ';charset=' + options.charset;\n                }\n                xhr.setRequestHeader('Content-Type', contentType);\n                xhr.send(query);\n            }\n\n            if (options.timeout > 0) {\n                var notifyTimeout = function () {\n                    /**\n                     * @event timeout\n                     *\n                     * 任意一个请求成功时触发，\n                     * 在此事件后会再触发一次{@link Ajax#fail}事件\n                     *\n                     * @param {meta.FakeXHR} xhr 请求对象\n                     * @param {meta.AjaxOption} options 请求的配置信息\n                     */\n                    this.fire(\n                        'timeout',\n                        { xhr: fakeXHR, options: options }\n                    );\n                    fakeXHR.status = 408; // HTTP 408: Request Timeout\n                    fakeXHR.abort();\n                };\n                var tick = setTimeout(util.bind(notifyTimeout, this), options.timeout);\n                fakeXHR.ensure(function () { clearTimeout(tick); });\n            }\n\n            return fakeXHR;\n        };\n\n        /**\n         * 发起一个`GET`请求\n         *\n         * @param {string} url 请求的地址\n         * @param {Object} [data] 请求的数据\n         * @param {boolean} [cache] 决定是否允许缓存\n         * @return {meta.FakeXHR}\n         */\n        exports.get = function (url, data, cache) {\n            var options = {\n                method: 'GET',\n                url: url,\n                data: data,\n                cache: cache || this.config.cache\n            };\n            return this.request(options);\n        };\n\n        /**\n         * 发起一个`GET`请求并获取JSON数据\n         *\n         * @param {string} url 请求的地址\n         * @param {Object} [data] 请求的数据\n         * @param {boolean} [cache] 决定是否允许缓存\n         * @return {meta.FakeXHR}\n         */\n        exports.getJSON = function (url, data, cache) {\n            var options = {\n                method: 'GET',\n                url: url,\n                data: data,\n                dataType: 'json',\n                cache: cache || this.config.cache\n            };\n            return this.request(options);\n        };\n\n\n        /**\n         * 发起一个`POST`请求\n         *\n         * @param {string} url 请求的地址\n         * @param {Object} [data] 请求的数据\n         * @param {string} [dataType=\"json\"] 指定响应的数据格式\n         * @return {meta.FakeXHR}\n         */\n        exports.post = function (url, data, dataType) {\n            var options = {\n                method: 'POST',\n                url: url,\n                data: data,\n                dataType: dataType || 'json'\n            };\n            return this.request(options);\n        };\n\n        /**\n         * 发送一个日志请求，该请求只负责发出，不负责保证送达，且不支持回调函数\n         *\n         * @param {string} url 发送的目标URL\n         * @param {Object} [data] 额外添加的参数\n         */\n        exports.log = function (url, data) {\n            var img = new Image();\n            var pool = window.ER_LOG_POOL || (window.ER_LOG_POOL = {});\n            var id = +new Date();\n            pool[id] = img;\n\n            img.onload = img.onerror = img.onabort = function () {\n                // 如果这个img很不幸正好加载了一个存在的资源，又是个gif动画，\n                // 则在gif动画播放过程中，img会多次触发onload，因此一定要清空\n                img.onload = img.onerror = img.onabort = null;\n\n                pool[id] = null;\n\n                // 下面这句非常重要，\n                // new Image创建的是DOM，\n                // DOM的事件中形成闭包环引用DOM是典型的内存泄露，\n                // 因此这里一定要置为null\n                img = null;\n            };\n\n            var query = this.hooks.serializeData('', data, 'application/x-www-form-urlencoded');\n            if (query) {\n                var delimiter = url.indexOf('?') >= 0 ? ':' : '?';\n                url += delimiter + query;\n            }\n            // 一定要在注册了事件之后再设置src，\n            // 不然如果图片是读缓存的话，会错过事件处理，\n            // 最后，对于url最好是添加客户端时间来防止缓存，\n            // 同时服务器也配合一下传递`Cache-Control: no-cache;`\n            img.src = url;\n        };\n\n        var Ajax = require('eoo').create(require('fc-mini-event/EventTarget'), exports);\n        var instance = new Ajax();\n        instance.Ajax = Ajax;\n        return instance;\n    }\n);\n"]} |